{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "hidden_ranges": [],
        "originalKey": "6778d143-3808-45b3-bcbe-da7c7475280a",
        "showInput": false
      },
      "source": [
        "# Bayesian Optimization with Preference Exploration\n",
        "\n",
        "In this tutorial, we demonstrate how to implement a closed loop of Bayesian optimization with preference exploration, or BOPE [1].\n",
        "BOPE is designed for Bayesian optimization of expensive-to-evaluate experiments,\n",
        "where the response surface function of the experiment $f_\\mathrm{true}$ generates vector-valued outcomes over which a decision-maker (DM) has preferences.\n",
        "These preferences are encoded by a utility function $g_\\mathrm{true}$ that is not known in closed form but can be estimated by\n",
        "asking the DM to express preferences over pairs of outcome vectors.\n",
        "\n",
        "In other words, with BOPE, we wish to solve the following optimization problem:\n",
        "\n",
        "$$\n",
        " \\max_{x \\in \\mathcal{X}} g_\\mathrm{true}(f_\\mathrm{true}(x))\n",
        "$$\n",
        "\n",
        "Unlike many other Bayesian optimization setups where multiple consecutive batches of experiments are performed,\n",
        "in BOPE, we alternate between two stages: *preference exploration* and *experimentation*.\n",
        "\n",
        "In the preference exploration stage, we use an acquisition function (i.e., a preference exploration strategy, or PE strategy)\n",
        "to adaptively generate pairs of hypothetical outcome and ask the decision-maker’s preference within each pair.\n",
        "In the experimentation stage, we use a batch version of noisy expected improvement that integrates over our uncertainty in the\n",
        "utility function called $\\text{qNEIUU}$ to generate experimental candidates for evaluation.\n",
        "\n",
        "\n",
        "[1] [Z.J. Lin, R. Astudillo, P.I. Frazier, and E. Bakshy, Preference Exploration for Efficient Bayesian Optimization with Multiple Outcomes. AISTATS, 2022.](https://arxiv.org/abs/2203.11382)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Install dependencies if we are running in colab\n",
        "import sys\n",
        "if 'google.colab' in sys.modules:\n",
        "    %pip install botorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "customInput": null,
        "customOutput": null,
        "executionStartTime": 1679689485463,
        "executionStopTime": 1679689500450,
        "originalKey": "f4c4c433-22c1-432c-8b68-e994bcd1881b",
        "output": {
          "id": 795773092378270,
          "loadingStatus": "loaded"
        },
        "requestMsgId": "9aa7b0c4-ac2c-4e47-a067-7e0797bdd89d",
        "showInput": true
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "I0214 125107.545 font_manager.py:1550] generated new fontManager\n",
            "I0214 125107.837 _utils_internal.py:247] NCCL_DEBUG env var is set to None\n",
            "I0214 125107.838 _utils_internal.py:265] NCCL_DEBUG is forced to WARN from None\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "from typing import Optional, Tuple\n",
        "\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pylab as plt\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "from botorch.acquisition import (\n",
        "    GenericMCObjective,\n",
        "    LearnedObjective,\n",
        "    MCAcquisitionObjective,\n",
        ")\n",
        "from botorch.acquisition.logei import qLogNoisyExpectedImprovement\n",
        "from botorch.acquisition.monte_carlo import qSimpleRegret\n",
        "from botorch.acquisition.preference import AnalyticExpectedUtilityOfBestOption\n",
        "from botorch.fit import fit_gpytorch_mll\n",
        "from botorch.models.deterministic import FixedSingleSampleModel\n",
        "from botorch.models.gp_regression import SingleTaskGP\n",
        "from botorch.models.pairwise_gp import PairwiseGP, PairwiseLaplaceMarginalLogLikelihood\n",
        "from botorch.models.transforms.input import Normalize\n",
        "from botorch.optim.optimize import optimize_acqf\n",
        "from botorch.sampling import SobolQMCNormalSampler\n",
        "from botorch.test_functions.multi_objective import DTLZ2\n",
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood\n",
        "\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "# Set plotting colors\n",
        "colors = [\"tab:blue\", \"tab:orange\", \"tab:green\", \"tab:red\"]\n",
        "mpl.rcParams[\"axes.prop_cycle\"] = mpl.cycler(color=colors)\n",
        "\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "hidden_ranges": [],
        "originalKey": "7729000d-0661-4689-8f2b-f99e32c52b70",
        "showInput": false
      },
      "source": [
        "## Problem Setup\n",
        "\n",
        "In this tutorial, we use the DTLZ2 problem with d=5 inputs and k=4 outcomes as our test problem $f_\\mathrm{true}$.\n",
        "\n",
        "For the utility function $g_\\mathrm{true}$, we use the negative L1 distance from a Pareto-optimal point the outcome space:\n",
        "$Y^* = f(X^*)$ where $X^* = [0.5, 0.5, 0.5, 0.5, 0.5]$. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "customOutput": null,
        "executionStartTime": 1679689500531,
        "executionStopTime": 1679689500534,
        "hidden_ranges": [],
        "originalKey": "470d8e92-e1ff-4ae7-8343-3423273900f8",
        "requestMsgId": "f8b170ce-5da8-40f6-aae4-1d637ea97e33",
        "showInput": true
      },
      "outputs": [],
      "source": [
        "def neg_l1_dist(Y: torch.Tensor, X: Optional[torch.Tensor] = None) -> torch.Tensor:\n",
        "    \"\"\"Negative L1 distance from a Pareto optimal points\"\"\"\n",
        "    if len(Y.shape) == 1:\n",
        "        Y = Y.unsqueeze(0)\n",
        "    dist = torch.cdist(\n",
        "        Y, torch.full(Y.shape[-1:], fill_value=0.5, dtype=Y.dtype).unsqueeze(0), p=1\n",
        "    ).squeeze(-1)\n",
        "    return -dist\n",
        "\n",
        "\n",
        "if SMOKE_TEST:\n",
        "    NUM_RESTARTS = 2\n",
        "    NUM_OUTCOME_SAMPLES = 2\n",
        "    RAW_SAMPLES = 4\n",
        "    BATCH_LIMIT = 2\n",
        "else:\n",
        "    NUM_RESTARTS = 8\n",
        "    # Since BOPE samples from both the outcome and preference models, we take\n",
        "    # fewer samples than usual from the outcome model for speed.\n",
        "    NUM_OUTCOME_SAMPLES = 32\n",
        "    RAW_SAMPLES = 64\n",
        "    BATCH_LIMIT = 4\n",
        "\n",
        "X_dim = 5\n",
        "Y_dim = 4\n",
        "problem = DTLZ2(dim=X_dim, num_objectives=Y_dim)\n",
        "util_func = neg_l1_dist"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "hidden_ranges": [],
        "originalKey": "bf98ebb8-36d5-423a-9eea-5ff99c44975b",
        "showInput": false
      },
      "source": [
        "Here we define a collection of helper functions for BOPE:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "customOutput": null,
        "executionStartTime": 1679689500831,
        "executionStopTime": 1679689500838,
        "hidden_ranges": [],
        "originalKey": "8a6b9736-1ba8-4914-b295-7406bec5ece6",
        "requestMsgId": "43fea609-1909-4ba8-af8f-7ac3de4016dd",
        "showInput": true
      },
      "outputs": [],
      "source": [
        "def fit_outcome_model(X: torch.Tensor, Y: torch.Tensor) -> SingleTaskGP:\n",
        "    \"\"\"Fit the outcome model f\"\"\"\n",
        "    outcome_model = SingleTaskGP(\n",
        "        train_X=X,\n",
        "        train_Y=Y,\n",
        "        input_transform=Normalize(d=X.shape[-1]),\n",
        "    )\n",
        "    mll = ExactMarginalLogLikelihood(outcome_model.likelihood, outcome_model)\n",
        "    fit_gpytorch_mll(mll)\n",
        "    return outcome_model\n",
        "\n",
        "\n",
        "def fit_pref_model(Y: torch.Tensor, comps: torch.Tensor) -> PairwiseGP:\n",
        "    \"\"\"Fit the preference model g.\"\"\"\n",
        "    model = PairwiseGP(Y, comps, input_transform=Normalize(d=Y.shape[-1]))\n",
        "    mll = PairwiseLaplaceMarginalLogLikelihood(model.likelihood, model)\n",
        "    fit_gpytorch_mll(mll)\n",
        "    return model\n",
        "\n",
        "\n",
        "def gen_rand_X(problem, n: int) -> torch.Tensor:\n",
        "    \"\"\"Generate n quasi-random Sobol points in the design space.\"\"\"\n",
        "    return draw_sobol_samples(bounds=problem.bounds, n=1, q=n).squeeze(0)\n",
        "\n",
        "\n",
        "def generate_random_exp_data(problem, n: int) -> Tuple[torch.Tensor, torch.Tensor]:\n",
        "    \"\"\"Generate n observations of (X, Y) Pairs\"\"\"\n",
        "    X = gen_rand_X(problem, n)\n",
        "    Y = problem(X)\n",
        "    return X, Y\n",
        "\n",
        "\n",
        "def generate_random_pref_data(\n",
        "    outcome_model: SingleTaskGP, n: int\n",
        ") -> Tuple[torch.Tensor, torch.Tensor]:\n",
        "    \"\"\"Generate n pairwise comparison data between 2n points.\"\"\"\n",
        "    X = gen_rand_X(problem, 2 * n)\n",
        "    Y = outcome_model.posterior(X).sample().squeeze(0)\n",
        "    util = util_func(Y)\n",
        "    comps = gen_comps(util)\n",
        "    return Y, comps\n",
        "\n",
        "\n",
        "def gen_comps(util: torch.Tensor) -> torch.Tensor:\n",
        "    \"\"\"Given an 1-d tensor of utility, create pairwise comparisons between adjacent items.\"\"\"\n",
        "    util = util.reshape(-1, 2)\n",
        "    comps = torch.arange(util.numel()).reshape(-1, 2)\n",
        "    flip = util[:, 0] < util[:, 1]\n",
        "    comps[flip, [0]], comps[flip, [1]] = comps[flip, [1]], comps[flip, [0]]\n",
        "\n",
        "    return comps\n",
        "\n",
        "\n",
        "def run_pref_learn(\n",
        "    outcome_model: SingleTaskGP,\n",
        "    train_Y: torch.Tensor,\n",
        "    train_comps: torch.Tensor,\n",
        "    n_comps: int,\n",
        "    pe_strategy: str,\n",
        "    verbose: bool = False,\n",
        ") -> Tuple[torch.Tensor, torch.Tensor]:\n",
        "    \"\"\"Perform preference exploration with a given PE strategy for n_comps rounds.\"\"\"\n",
        "    for i in range(n_comps):\n",
        "        if verbose:\n",
        "            print(f\"Running {i+1}/{n_comps} preference learning using {pe_strategy}\")\n",
        "        pref_model = fit_pref_model(train_Y, train_comps)\n",
        "        if pe_strategy == \"EUBO-zeta\":\n",
        "            # EUBO-zeta\n",
        "            one_sample_outcome_model = FixedSingleSampleModel(model=outcome_model)\n",
        "            acqf = AnalyticExpectedUtilityOfBestOption(\n",
        "                pref_model=pref_model, outcome_model=one_sample_outcome_model\n",
        "            )\n",
        "            cand_X, acqf_val = optimize_acqf(\n",
        "                acq_function=acqf,\n",
        "                q=2,\n",
        "                bounds=problem.bounds,\n",
        "                num_restarts=NUM_RESTARTS,\n",
        "                raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "                options={\"batch_limit\": BATCH_LIMIT},\n",
        "            )\n",
        "            cand_Y = one_sample_outcome_model(cand_X)\n",
        "        elif pe_strategy == \"Random-f\":\n",
        "            # Random-f\n",
        "            cand_X = gen_rand_X(problem, n=2)\n",
        "            cand_Y = outcome_model.posterior(cand_X).sample().squeeze(0)\n",
        "        else:\n",
        "            raise RuntimeError(\"Unknown preference exploration strategy!\")\n",
        "\n",
        "        cand_Y = cand_Y.detach().clone()\n",
        "        cand_comps = gen_comps(util_func(cand_Y))\n",
        "\n",
        "        train_comps = torch.cat((train_comps, cand_comps + train_Y.shape[0]))\n",
        "        train_Y = torch.cat((train_Y, cand_Y))\n",
        "\n",
        "    return train_Y, train_comps\n",
        "\n",
        "\n",
        "def gen_exp_cand(\n",
        "    outcome_model: SingleTaskGP,\n",
        "    objective: MCAcquisitionObjective,\n",
        "    q: int,\n",
        "    acqf_name: str,\n",
        ") -> torch.Tensor:\n",
        "    \"\"\"Given an outcome model and an objective, generate q experimental candidates\n",
        "    using specified acquisition function.\"\"\"\n",
        "    sampler = SobolQMCNormalSampler(sample_shape=torch.Size([NUM_OUTCOME_SAMPLES]))\n",
        "    if acqf_name == \"qNEI\":\n",
        "        # generate experimental candidates with qNEI/qNEIUU\n",
        "        acq_func = qLogNoisyExpectedImprovement(\n",
        "            model=outcome_model,\n",
        "            objective=objective,\n",
        "            X_baseline=X,\n",
        "            sampler=sampler,\n",
        "            prune_baseline=True,\n",
        "        )\n",
        "    elif acqf_name == \"posterior_mean\":\n",
        "        # generate experimental candidates with maximum posterior mean\n",
        "        acq_func = qSimpleRegret(\n",
        "            model=outcome_model,\n",
        "            sampler=sampler,\n",
        "            objective=objective,\n",
        "        )\n",
        "    else:\n",
        "        raise RuntimeError(\"Unknown acquisition function name!\")\n",
        "\n",
        "    # optimize the acquisition function\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        q=q,\n",
        "        bounds=problem.bounds,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,\n",
        "        options={\"batch_limit\": BATCH_LIMIT},\n",
        "        sequential=True,\n",
        "    )\n",
        "    return candidates\n",
        "\n",
        "\n",
        "def find_max_posterior_mean(\n",
        "    outcome_model: SingleTaskGP,\n",
        "    train_Y: torch.Tensor,\n",
        "    train_comps: torch.Tensor,\n",
        "    verbose: bool = False,\n",
        "):\n",
        "    \"\"\"Helper function that find the max posterior mean under current outcome and\n",
        "    preference model\"\"\"\n",
        "    pref_model = fit_pref_model(train_Y, train_comps)\n",
        "    pref_obj = LearnedObjective(pref_model=pref_model)\n",
        "    post_mean_cand_X = gen_exp_cand(\n",
        "        outcome_model, pref_obj, q=1, acqf_name=\"posterior_mean\"\n",
        "    )\n",
        "\n",
        "    post_mean_util = util_func(problem(post_mean_cand_X)).item()\n",
        "    if verbose:\n",
        "        print(f\"Max posterior mean utility: {post_mean_util:.3f}\")\n",
        "    within_result = {\n",
        "        \"n_comps\": train_comps.shape[0],\n",
        "        \"util\": post_mean_util,\n",
        "    }\n",
        "    return within_result"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "hidden_ranges": [],
        "originalKey": "7d9d4982-ca40-4744-88d5-775a5c306ddd",
        "showInput": false
      },
      "source": [
        "## Closed Loop BOPE\n",
        "\n",
        "### Setup\n",
        "The following cell shows the core part of this tutorial.\n",
        "In BOPE, we use two probablistic models (in this case, two Gaussian processes) $f$ and $g$\n",
        "to model $f_\\mathrm{true}$ and $g_\\mathrm{true}$ respectively.\n",
        "\n",
        "We start by initializing the outcome model $f$ with 8 quasi-random points (the initial experimentation stage).\n",
        "\n",
        "Next, we enter the preference exploration (PE) stage.\n",
        "A straightforward strategy of performing PE is to present the decision-maker with comparisons using outcomes sampled from the outcome model at random design points. We refer this method as $\\text{Random}\\mathrm{-}f$.\n",
        "\n",
        "Alternatively, we could initialize the preference model with $\\text{Random}\\mathrm{-}f$,\n",
        "then perform PE using the $\\text{EUBO}\\mathrm{-}\\zeta$ acquisition function as proposed in [1].\n",
        "<!-- \\tilde{f} somehow is not rendering --> \n",
        "\n",
        "In this tutorial, we examine both strategies by starting with initializating the preference model with 3 comparisons using $\\text{Random}\\mathrm{-}f$.\n",
        "After that, we perform 3 * 5 = 15 pairwise comparisons using either $\\text{EUBO}\\mathrm{-}\\zeta$ or $\\text{Random}\\mathrm{-}f$.\n",
        "Then we move on to the second experimentation stage by generating a candidate using qNEIUU by\n",
        "leveraging both the outcome model and the learned preference model.\n",
        "\n",
        "We additionally examine two other experimental candidate generation strategies:\n",
        "* \"True utility\": We assume the true utility function is known and generate experiment candidate(s) using qLogNEI. This represents the performance upper bound of PE strategies.\n",
        "* \"Random experiment\": We use random design points to generate new candidates.\n",
        "\n",
        "In this tutorial, we only run one replication of this benchmark; while in general we would expect \"True utility\" to outperform $\\text{EUBO}\\mathrm{-}\\zeta$ and $\\text{EUBO}\\mathrm{-}\\zeta$ to outperform\n",
        "the other strategies, this is not guaranteed for a optimization."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "customOutput": null,
        "executionStartTime": 1679689500952,
        "executionStopTime": 1679689626563,
        "hidden_ranges": [],
        "originalKey": "4067171b-e552-4ddf-a9e8-a40b53a5c368",
        "output": {
          "id": 355724710606511,
          "loadingStatus": "loaded"
        },
        "requestMsgId": "b824d249-226a-497e-8764-fea353877527",
        "showInput": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "EUBO-zeta qNEIUU candidate utility: -1.026\n",
            "Random-f qNEIUU candidate utility: -1.226\n",
            "True objective utility: -1.004\n",
            "Random experiment utility: -1.380\n"
          ]
        }
      ],
      "source": [
        "verbose = False\n",
        "# Number of pairwise comparisons performed before checking posterior mean\n",
        "every_n_comps = 3\n",
        "# Total number of checking the maximum posterior mean\n",
        "n_check_post_mean = 1 if SMOKE_TEST else 5\n",
        "n_outcome_model_initialization_points = 8\n",
        "within_session_results = []\n",
        "exp_candidate_results = []\n",
        "\n",
        "# Experimentation stage: initial exploration batch\n",
        "torch.manual_seed(0)\n",
        "np.random.seed(0)\n",
        "X, Y = generate_random_exp_data(problem, n_outcome_model_initialization_points)\n",
        "outcome_model = fit_outcome_model(X, Y)\n",
        "\n",
        "# Preference exploration stage: initialize the preference model with comparsions\n",
        "# between pairs of outcomes estimated using random design points\n",
        "init_train_Y, init_train_comps = generate_random_pref_data(outcome_model, n=1)\n",
        "\n",
        "# Perform preference exploration using either Random-f or EUBO-zeta\n",
        "for pe_strategy in [\"EUBO-zeta\", \"Random-f\"]:\n",
        "    train_Y, train_comps = init_train_Y.clone(), init_train_comps.clone()\n",
        "    within_result = find_max_posterior_mean(outcome_model, train_Y, train_comps)\n",
        "    within_result.update({\"pe_strategy\": pe_strategy})\n",
        "    within_session_results.append(within_result)\n",
        "\n",
        "    for j in range(n_check_post_mean):\n",
        "        train_Y, train_comps = run_pref_learn(\n",
        "            outcome_model,\n",
        "            train_Y,\n",
        "            train_comps,\n",
        "            n_comps=every_n_comps,\n",
        "            pe_strategy=pe_strategy,\n",
        "            verbose=verbose,\n",
        "        )\n",
        "        if verbose:\n",
        "            print(\n",
        "                f\"Checking posterior mean after {(j+1) * every_n_comps} comps using PE strategy {pe_strategy}\"\n",
        "            )\n",
        "        within_result = find_max_posterior_mean(\n",
        "            outcome_model, train_Y, train_comps, verbose=verbose\n",
        "        )\n",
        "        within_result.update({\"pe_strategy\": pe_strategy})\n",
        "        within_session_results.append(within_result)\n",
        "\n",
        "    # Going back to the experimentation stage: generate an additional batch of experimental evaluations\n",
        "    # with the learned preference model and qNEIUU\n",
        "    pref_model = fit_pref_model(train_Y, train_comps)\n",
        "    pref_obj = LearnedObjective(pref_model=pref_model)\n",
        "    exp_cand_X = gen_exp_cand(outcome_model, pref_obj, q=1, acqf_name=\"qNEI\")\n",
        "    qneiuu_util = util_func(problem(exp_cand_X)).item()\n",
        "    print(f\"{pe_strategy} qNEIUU candidate utility: {qneiuu_util:.3f}\")\n",
        "    exp_result = {\"util\": qneiuu_util, \"strategy\": pe_strategy}\n",
        "    exp_candidate_results.append(exp_result)\n",
        "\n",
        "# Generate a batch of experimental evaluations using oracle and random baselines\n",
        "# True utility\n",
        "true_obj = GenericMCObjective(util_func)\n",
        "true_obj_cand_X = gen_exp_cand(outcome_model, true_obj, q=1, acqf_name=\"qNEI\")\n",
        "true_obj_util = util_func(problem(true_obj_cand_X)).item()\n",
        "print(f\"True objective utility: {true_obj_util:.3f}\")\n",
        "exp_result = {\"util\": true_obj_util, \"strategy\": \"True Utility\"}\n",
        "exp_candidate_results.append(exp_result)\n",
        "\n",
        "# Random experiment\n",
        "_, random_Y = generate_random_exp_data(problem, 1)\n",
        "random_util = util_func(random_Y).item()\n",
        "print(f\"Random experiment utility: {random_util:.3f}\")\n",
        "exp_result = {\"util\": random_util, \"strategy\": \"Random Experiment\"}\n",
        "exp_candidate_results.append(exp_result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "hidden_ranges": [],
        "originalKey": "64f2fb33-46bc-47ac-b169-ea702e41f6cd",
        "showInput": false
      },
      "source": [
        "## Plot the Results\n",
        "\n",
        "We evaluate our results by creating two plots.\n",
        "\n",
        "In the first plot, we focus on comparing how $\\text{EUBO}\\mathrm{-}\\zeta$ can efficiently identify the maximizer \n",
        "of $g_\\mathrm{true}(f_\\mathrm{true}(x))$ within a preference exploration stage.\n",
        "We examine this by estimating the maximum posterior mean after every 3 pairwise comparisons.\n",
        "\n",
        "Here, we plot the the max utility value identified using $\\text{EUBO}\\mathrm{-}\\zeta$ and $\\text{Random}\\mathrm{-}f$\n",
        "with increasing number of pairwise comparisons.\n",
        "As we can see in this plot, the preference model learned using $\\text{EUBO}\\mathrm{-}\\zeta$ is able to identify the maximum utility more efficiently."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "output": {
          "id": 416769047589601,
          "loadingStatus": "loaded"
        }
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f2fac5f6230>"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "for name, group in pd.DataFrame(within_session_results).groupby(\n",
        "    \"pe_strategy\", sort=True\n",
        "):\n",
        "    plt.plot(\n",
        "        group[\"n_comps\"],\n",
        "        group[\"util\"],\n",
        "        label=name,\n",
        "        linewidth=1.5,\n",
        "    )\n",
        "plt.xlabel(\"Number of comparisons\")\n",
        "plt.ylabel(\"Max value identified\")\n",
        "plt.legend(title=\"PE Strategy\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "hidden_ranges": [],
        "originalKey": "e407a6c3-0cf3-4ec2-886a-4973db669ceb",
        "showInput": false
      },
      "source": [
        "In the following cell, we show the utility values achieved using different methods in the 2nd experimentation stage.\n",
        "\n",
        "In repeated iterations -- not done here for speed and succinctness -- we find that\n",
        "$\\text{EUBO}\\mathrm{-}\\zeta$, as a one-step Bayesian optimal PE strategy, performs very similarly to the true utility strategy on average.\n",
        "On the other hand, even though $\\text{Random}\\mathrm{-}f$ is a relatively straightforward PE strategy,\n",
        "it is still able to suggest experimental candidates with generally higher utility values than the random experiment baseline.\n",
        "\n",
        "For more rigorous performance comparisons, see [1]."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "customOutput": null,
        "executionStartTime": 1679689627689,
        "executionStopTime": 1679689628137,
        "hidden_ranges": [],
        "originalKey": "0737e625-fe4a-47e5-bc4c-ffabb9511435",
        "output": {
          "id": 710845344563787,
          "loadingStatus": "loaded"
        },
        "requestMsgId": "5791d879-9ccc-4be5-a671-b3ac431978f4",
        "showInput": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f2f9e963eb0>"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "for result in exp_candidate_results:\n",
        "    plt.scatter(\n",
        "        [result[\"strategy\"]],\n",
        "        [result[\"util\"]],\n",
        "        s=100,\n",
        "        label=result[\"strategy\"],\n",
        "    )\n",
        "\n",
        "plt.xlabel(\"Experimentation Strategy\")\n",
        "plt.ylabel(\"Utility achieved in the 2nd experiment stage\")\n",
        "plt.legend(title=\"Experimentation Strategy\")"
      ]
    }
  ],
  "metadata": {
    "custom": {
      "cells": [],
      "metadata": {
        "fileHeader": "",
        "fileUid": "27675a89-3363-4f66-a496-3c1159099da2",
        "isAdHoc": false,
        "kernelspec": {
          "display_name": "python3",
          "language": "python",
          "name": "python3"
        },
        "orig_nbformat": 4
      },
      "nbformat": 4,
      "nbformat_minor": 2
    },
    "fileHeader": "",
    "fileUid": "cebcfd90-71e6-4e23-8a86-5514816cb017",
    "indentAmount": 2,
    "isAdHoc": false,
    "kernelspec": {
      "display_name": "python3",
      "language": "python",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}
